//
//  GhSqliteDb.cpp
//  poker
//
//  Created by 郭浩 on 15/3/18.
//
//

#include "GhSqliteDb.h"
#include <string>

using namespace std;

/////////////////////////////////////////////////////////
GhSqliteDb::GhSqliteDb() :
m_pkDatabase(NULL)
{
    
}
/////////////////////////////////////////////////////////
GhSqliteDb::~GhSqliteDb()
{
    m_kRowDataVector.clear();

    if (m_pkDatabase)
    {
        sqlite3_close (m_pkDatabase);
    }
}
/////////////////////////////////////////////////////////
void GhSqliteDb::initDataBase(const char* pszDBName)
{
    if (0 == pszDBName || !*pszDBName)
    {
        printf("0 == pszDBName || !*pszDBName");
        return;
    }
    
    m_strDBName = pszDBName;
    m_strPath = getDBPath(pszDBName);
    
    if (sqlite3_open(m_strPath.c_str(), &m_pkDatabase) != SQLITE_OK)
    {
        return;
    }
}

/////////////////////////////////////////////////////////
int GhSqliteDb::selectData(const char* pszSelectSql, int nColNum)
{
    m_kRowDataVector.clear();

    if (!m_pkDatabase)
    {
        return 0;
    }
    
    sqlite3_stmt* pkStatement = 0;

    if (sqlite3_prepare_v2(m_pkDatabase, pszSelectSql, -1, &pkStatement, NULL)
        != SQLITE_OK)
    {
        return 0;
    }
    
    int nRowNum = 0;

    while (sqlite3_step(pkStatement) == SQLITE_ROW)
    {
        VEC_COL_DATA setColData;

        for (int nCol = 0; nCol < nColNum; nCol++)
        {
            std::string strData = (const char*) sqlite3_column_text(pkStatement,nCol);
            setColData.push_back(strData);
        }

        m_kRowDataVector.push_back(setColData);
        nRowNum++;
    }

    sqlite3_finalize(pkStatement);

    return nRowNum;
}

/////////////////////////////////////////////////////////
bool GhSqliteDb::isExistTable(const char* pszTableName)
{
    if (!m_pkDatabase)
    {
        return false;
    }
    
    std::string strSelectSql = "select * from ";
    strSelectSql += pszTableName;
    char* szErrMsg = NULL;

    if (sqlite3_exec(m_pkDatabase, strSelectSql.c_str(), 0, 0, &szErrMsg)
        != SQLITE_OK)
    {
        return false;
    }

    return true;
}

/////////////////////////////////////////////////////////
bool GhSqliteDb::excuteSql(const char* pszSql)
{
    if (!pszSql)
    {
        return false;
    }

    if (!m_pkDatabase)
    {
        return false;
    }

    char* pszErrorMessage = 0;

    if (sqlite3_exec(m_pkDatabase, pszSql, 0, 0, &pszErrorMessage) != SQLITE_OK)
    {
        if (pszErrorMessage)
        {
            printf("Execute sqlite error!msg: %s\n",pszErrorMessage);
        }
        
        return false;
    }
    
    return true;
}

/////////////////////////////////////////////////////////
int GhSqliteDb::getColDataN(int nIdx, int nFieldIdx)
{
    if (nIdx < (int)m_kRowDataVector.size())
    {
        VEC_COL_DATA& rSetCol = m_kRowDataVector[nIdx];

        if (nFieldIdx < (int)rSetCol.size())
        {
            return stoi(rSetCol[nFieldIdx].c_str());
        }
    }

    return 0;
}

/////////////////////////////////////////////////////////
const char* GhSqliteDb::getColDataS(int nIdx, int nFieldIdx)
{
    if (nIdx < (int)m_kRowDataVector.size())
    {
        VEC_COL_DATA& rSetCol = m_kRowDataVector[nIdx];

        if (nFieldIdx < (int)rSetCol.size())
        {
            return rSetCol[nFieldIdx].c_str();
        }
    }

    return NULL;
}

//private:
/////////////////////////////////////////////////////////
void GhSqliteDb::releaseData(void)
{
    m_kRowDataVector.clear();
}
/////////////////////////////////////////////////////////
std::string GhSqliteDb::getDBPath(const char* pszDBName)
{
    string strPath = "";
    string strFullDBPath = pszDBName;
    
    if (0 == pszDBName || !*pszDBName)
    {
        return strPath;
    }
    
    return strFullDBPath;
}

const char* GhSqliteDb::getName()
{
    return m_strDBName.c_str();
}